home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DNet / DGoClasses.cpp < prev    next >
Text File  |  1996-07-05  |  58KB  |  2,344 lines
  1. // DGopherClasses.cp
  2.  
  3. #include <ncbi.h>
  4. #include <dgg.h>
  5. #include <Dvibrant.h>
  6.  
  7. #include "DTCP.h"
  8. #include "DGopher.h"
  9. #include "DGoList.h"
  10. #include "DGoInit.h"
  11. #include "DGoPlus.h"
  12. #include "DGoClasses.h"
  13.  
  14. #include <DWindow.h>
  15. #include <DControl.h>
  16. #include <DDialogText.h>
  17. #include <DSendMailDialog.h>
  18. #include <DApplication.h>
  19. #include <DUtil.h>
  20.  
  21.  
  22. static const    long kReadMaxbuf1 = 1 * 1024;
  23. static const    long kMaxMemory     = 20 * 1024; // sure wish we could measure app free memory !!
  24.  
  25. const long    kGopherFileType     =
  26. #ifdef WIN_MSWIN
  27. 1234;
  28. #else
  29. 'IGo4'; // dup of SeqGopher.h const
  30. #endif
  31.  
  32.  
  33. //typedef    AppFile    *AppFilePtr;
  34.  
  35. // DFolderGopher -----------------------------
  36.  
  37.  
  38. void DFolderGopher::Initialize()
  39. {
  40.     fMacType= kGopherFileType; //TEXT  
  41.     fMacSire= kGopherFileType; //EDIT
  42.     fTransferType= kTransferBinary; //kTransferText; //text/lines or binary or none ?
  43.     fSaveToDisk= false;
  44.     fLaunch= false;
  45.     fCommand= cNewGopherFolder;
  46. }
  47.  
  48.  
  49.  
  50. DFolderGopher::DFolderGopher() 
  51. {
  52.     Initialize(); // my mistake -- 
  53.         // the base class Initialize() is called by DGopher() 
  54.         // this subclassed Initialize() must be called by this subclass constructor
  55.         // I should have known that and written this differently (IGopher() and IFolderGopher() ??)
  56. }
  57.  
  58. DFolderGopher::DFolderGopher( DFolderGopher* aGopher): DGopher(aGopher)
  59. {
  60.     //Initialize(); -- no DGopher(aGopher) will set fields way we want (i hope)
  61. }
  62.  
  63. DFolderGopher::DFolderGopher( char ctype, const char* link):
  64.     DGopher( ctype, link)
  65. {
  66.     Initialize();
  67. }
  68.  
  69.  
  70. DObject* DFolderGopher::Clone()
  71. {
  72.     DFolderGopher* aGopher= new DFolderGopher();
  73.     aGopher->CopyGopher( this);
  74.     return aGopher;
  75.     //return new DFolderGopher(this); << BAD, mangles this
  76. }
  77.  
  78. void DFolderGopher::DrawIcon( Nlm_RecT& area, short size)  
  79. {
  80.     gGopherIconID= kFolderIcon;
  81.     gIconSize= size;
  82.     DrawIconSub( area);
  83. }
  84.  
  85. const char* DFolderGopher::GetKindName() 
  86. { 
  87.     return "Folder";
  88. }
  89.  
  90.  
  91. void DFolderGopher::OpenQuery()
  92. {
  93.     if (fQueryPlus != NULL)  ;             // if wrapper has set this (for +ASK reply) leave it
  94.     else if (fIsPlus != kGopherPlusYes) fQueryPlus= NULL;
  95.     else {
  96.         // if sending viewform, can't send fQueryPlus !
  97.         if (fViewchoice) fQueryPlus= NULL;     // viewchoice conflicts w/ queryplus !!
  98.         else if (fShortFolder) fQueryPlus= "\t+"; // gopher+, call for short data
  99.         else fQueryPlus= "\t$";                                     // gopher+, call for all needed data
  100.         }
  101.         
  102.     DGopher::OpenQuery();        
  103. }
  104.  
  105. #if GOOBSOLETE
  106. short DFolderGopher::GopherIt() // override 
  107. {
  108.     ReadAll();
  109.     if (fInfo && fInfoSize>10) 
  110.         return cNewGopherFolder;
  111.     else  
  112.         return cNoCommand;
  113. }
  114.  
  115. #endif
  116.  
  117.  
  118.  
  119. // DTextGopher -----------------------------
  120.  
  121. #ifdef WIN_MSWIN
  122. long    DTextGopher::kMacType = 1234;
  123. long    DTextGopher::kMacSire = 4321;
  124. #else
  125. long    DTextGopher::kMacType = 'TEXT';
  126. long    DTextGopher::kMacSire = 'EDIT';
  127. #endif
  128. char * DTextGopher::kSuffix = ".text";
  129.  
  130. void DTextGopher::InitSignature()     
  131. {
  132.     if (gGopherMap) gGopherMap->GetPreferedFiletype("text/plain", kMacType, kMacSire, kSuffix);     
  133. }
  134.  
  135. void DTextGopher::Initialize()    // override 
  136. {
  137.     //? fType= kTypeFile; 
  138.     fMacType= kMacType; 
  139.     fMacSire= kMacSire; 
  140.     fTransferType= kTransferText; 
  141.     fSaveToDisk= false;
  142.     fLaunch= false;
  143.     fCommand= cNewGopherText;
  144. }
  145.  
  146. DTextGopher::DTextGopher(): DGopher()
  147. {
  148.     Initialize();
  149. }
  150.  
  151. DTextGopher::DTextGopher( DTextGopher* aGopher): DGopher(aGopher)
  152. {
  153.     //Initialize();
  154. }
  155.  
  156. DTextGopher::DTextGopher( char ctype, const char* link):
  157.     DGopher( ctype, link)
  158. {
  159.     Initialize();
  160. }
  161.  
  162.  
  163. DObject* DTextGopher::Clone()
  164. {
  165.     DTextGopher* aGopher= new DTextGopher();
  166.     aGopher->CopyGopher( this);
  167.     return aGopher;
  168. }
  169.  
  170. void DTextGopher::DrawIcon( Nlm_RecT& area, short size)  /* override */ 
  171. {
  172.     gGopherIconID= kTextIcon;
  173.     gIconSize= size;
  174.     DrawIconSub( area);
  175. }
  176.  
  177. const char* DTextGopher::GetKindName() 
  178. { 
  179.     return "Text document";
  180. }
  181.  
  182.  
  183. void DTextGopher::OpenQuery()
  184. {
  185.     if (fQueryPlus != NULL)  ;             // if wrapper has set this (for +ASK reply) leave it
  186.     else if (fIsPlus != kGopherPlusYes) fQueryPlus= NULL;
  187.     else fQueryPlus= "\t+"; // gopher+, this form forces server to send data size first
  188.  
  189.     DGopher::OpenQuery();        
  190.     if (fTalker) fTalker->NullTerm(true); //!?
  191.     if (fTransferType == kTransferText 
  192.             && fInfo && fInfoSize>0 && fInfo[fInfoSize] == kLF) 
  193.                 fInfo[fInfoSize--]= 0;  
  194. }
  195.  
  196.  
  197.  
  198. #if GOOBSOLETE
  199. short DTextGopher::GopherIt()
  200. {
  201.     short    command= cNoCommand;
  202.     Boolean tooBig= false;
  203.     Boolean FileIsMade= false;
  204.     long chunksize = kReadMaxbuf1; //Min( FreeMem()/2, kReadMaxbuf1);
  205.     long maxmemtext = kMaxMemory; //FreeMem();
  206.     //maxmemtext = maxmemtext - (maxmemtext / 3);
  207.  
  208.     OpenQuery();        
  209.     
  210.     if (fBytesExpected > 0) tooBig= (fBytesExpected > maxmemtext);
  211.  
  212. #if 1
  213.     if (fInfoHandler)
  214.      while (!EndOfMessage()) {
  215.             ReadAChunk( maxmemtext);
  216.             //(fInfoHandler)(this);
  217.             fInfoHandler->Process();
  218.             }
  219.     else
  220. #endif    
  221.     
  222.     while (!EndOfMessage()) {
  223.         if (tooBig || fSaveToDisk) {
  224.             fThreadState= kThreadReadingToDisk;
  225.             if (tooBig && fTalker) fTalker->ShowMessage("More text than app can display.");
  226.             FileIsMade= ReadToFile( chunksize);
  227.             if (FileIsMade) command= cOpenGopherText;
  228.             else command= cNewGopherText;
  229.             if (fTalker) fTalker->SetEndOfMessage(true);
  230.             }
  231.         else {
  232.             ReadAChunk( maxmemtext);
  233.             //tooBig= (!EndOfMessage());
  234.             if (fTalker) tooBig = (fTalker->NewBytesReceived() == -1);
  235.             command= cNewGopherText;
  236.             }
  237.         } 
  238.     
  239.     FinishRead();
  240.     if (fLaunch) { (void) this->LaunchFile(); command= cNoCommand; }
  241.     CloseQuery();
  242.     
  243.     return command;
  244. }
  245. #endif // GOOBSOLETE
  246.  
  247.  
  248.  
  249.  
  250.  
  251.  
  252.  
  253.  
  254.  
  255.  
  256. //    DIndexGopher    -----------------
  257.  
  258.             
  259. const short    kGopherSearchID    = 2204;    // dialog window for search query 
  260.                                                                         // do we want this public or private ?
  261.  
  262. class DIndexDialog : public DWindow
  263. {
  264. public:
  265.     static char *gLastQuery;
  266.     DEditText* fQuery;
  267.     
  268.     DIndexDialog( long id, DGopher* itsGoph) :
  269.         DWindow( id, gApplication, fixed, -10, -10, -50, -20, "Gopher Query", kDontFreeOnClose)
  270.     {
  271.         char *kSpacers = "                            "; // 28 spc
  272.         char    buf[255];
  273.         sprintf(buf,"%s?", (char*)itsGoph->GetName());
  274.         DPrompt* pr= new DPrompt(0, this, buf, 0, 0, Nlm_programFont);             
  275.         this->NextSubviewBelowLeft();
  276.         fQuery= new DEditText(0, this, kSpacers, 28); // save last query default???
  277.         fQuery->SetTitle(gLastQuery);
  278.         this->SetEditText(fQuery);
  279.         this->AddOkayCancelButtons(cOKAY,"Send");
  280.     }
  281.             
  282.     char* Result()
  283.     {
  284.         if (fOkay) {
  285.             //return fQuery->GetText();
  286.             long len = fQuery->TextLength();
  287.             if (!len) return NULL;
  288.             char *txt = (char*) MemNew(len+2);
  289.             *txt= '\t'; // precede word w/ tab for gopher
  290.             fQuery->GetTitle( txt+1, len+1);
  291.             if (gLastQuery) MemFree(gLastQuery);
  292.             gLastQuery= StrDup( txt+1);
  293.             return txt;
  294.             }
  295.         else return NULL;
  296.     }
  297.     
  298. };
  299.  
  300. char* DIndexDialog::gLastQuery = NULL;
  301.  
  302.  
  303. Boolean DIndexGopher::PoseQuestion(CharPtr& query)
  304. {
  305.     query= NULL; //?? we create this storage
  306.  
  307.     DIndexDialog* win= new DIndexDialog(0, this);
  308.     if ( win->PoseModally() ) ;
  309.     query= win->Result();
  310.     delete win;  
  311.     return (query != NULL);
  312. }
  313.         
  314. void DIndexGopher::InfoTask() 
  315. {    
  316.     fThreadState= kThreadDoneReading; 
  317. }
  318.  
  319.  
  320. void DIndexGopher::CloseQuery()
  321. {
  322.     DFolderGopher::CloseQuery();
  323.     if (fQuery) fQuery= (char*) MemFree( fQuery);
  324.  
  325. #if 0
  326.     char* kBombBugPatch = "i(Quick bug patch for obscure bomb)\t\t\t0"CRLF;    
  327.  
  328.     
  329.     DGopher* ago= new DGopher();
  330.     ago->SetLink( *fInfo, fInfo);
  331.     char link1[512];
  332.     sprintf( link1, "%c%s\t%s\t%s\t%d\t%c",
  333.         ago->fType, (char*) ago->GetName(), (char*) ago->GetPath(), 
  334.         (char*) ago->GetHost(), ago->fPort, ' ');
  335.     delete ago;
  336.     
  337.     char *next= fInfo;
  338.     next= StrChr(next, kLF);
  339.     if (next) next++;
  340.     
  341.     char *tmp= StrDup(kBombBugPatch);
  342.  
  343.     StrExtendCat( &tmp, link1);
  344.     StrExtendCat( &tmp, next);
  345.     //StrExtendCat( &tmp, fInfo);
  346.     MemFree(fInfo);
  347.     fInfo= tmp;
  348.     fInfoSize= StrLen(fInfo);
  349.  
  350. #endif
  351.  
  352. }
  353.  
  354. void DIndexGopher::OpenQuery()
  355. {
  356.     char*        query;                //?? need to save user query for doc word highlighting 
  357.     gCursor->arrow();
  358.     
  359.     if (fQueryGiven) {
  360.         fQuery= (char*) MemNew( 2 + StrLen(fQueryGiven));
  361.         fQuery[0]= '\t';
  362.         StrCpy(fQuery+1,fQueryGiven);
  363.         //DFolderGopher::OpenQuery(); << no, sends \t+ which leads client to ask for !info, which server can't produce
  364.         DGopher::OpenQuery();
  365.         }
  366.     else if (PoseQuestion(query)) { // this query str is made new for us
  367.         gCursor->watch();
  368.         fQuery= query;
  369.         //DFolderGopher::OpenQuery(); << no, sends \t+ which leads client to ask for !info, which server can't produce
  370.         DGopher::OpenQuery();
  371.         }
  372.     else {
  373.         fBytesExpected= 0;
  374.         fBytesReceived= 0;
  375.         if (fTalker) fTalker->SetEndOfMessage(true);
  376.         fThreadState= kThreadDoneReading;
  377.         //?? what will kill read??
  378.         }
  379. }
  380.         
  381.         
  382. #if GOOBSOLETE
  383. short DIndexGopher::GopherIt() // override 
  384. {
  385.     char*        query;                //?? need to save user query for doc word highlighting 
  386.     short    result= cNoCommand;
  387.     
  388.     result= DFolderGopher::GopherIt();
  389.     return result;
  390. }
  391. #endif// GOOBSOLETE
  392.  
  393.  
  394. void DIndexGopher::Initialize() 
  395. {
  396. }
  397.  
  398. DIndexGopher::DIndexGopher(): DFolderGopher()
  399. {
  400.     Initialize();
  401. }
  402.  
  403. DIndexGopher::DIndexGopher(DIndexGopher* aGopher): DFolderGopher(aGopher)
  404. {
  405.     //Initialize();
  406. }
  407.  
  408. DIndexGopher::DIndexGopher( char ctype, const char* link): DFolderGopher( ctype, link)
  409. {
  410.     Initialize();
  411. }
  412.  
  413. DObject* DIndexGopher::Clone()
  414. {
  415.     DIndexGopher* aGopher= new DIndexGopher();
  416.     aGopher->CopyGopher( this);
  417.     return aGopher;
  418. }
  419.  
  420. void DIndexGopher::DrawIcon( Nlm_RecT& area, short size)  /* override */ 
  421. {
  422.     gGopherIconID= kIndexIcon;
  423.     gIconSize= size;
  424.     DrawIconSub( area);
  425. }
  426.  
  427. const char* DIndexGopher::GetKindName() 
  428. { 
  429.     return "Query";
  430. }
  431.  
  432.  
  433.  
  434. #ifdef WIN_MSWIN
  435. long    DBinaryGopher::kMacType = 1235;
  436. long    DBinaryGopher::kMacSire = 3215;
  437. #else
  438. long    DBinaryGopher::kMacType = 'BINA';
  439. long    DBinaryGopher::kMacSire = '    ';
  440. #endif
  441. char * DBinaryGopher::kSuffix = ".binary";
  442.  
  443. void DBinaryGopher::InitSignature()     
  444. {
  445.     if (gGopherMap) gGopherMap->GetPreferedFiletype("file/-", kMacType, kMacSire, kSuffix);     
  446. }
  447.  
  448. void DBinaryGopher::Initialize()    // override 
  449. {
  450.     fMacType= kMacType; //'BINA';  
  451.     fMacSire= kMacSire; //'????';
  452.     fTransferType= kTransferBinary; //text/lines or binary or none ?
  453.     fSaveToDisk= true;
  454.     fLaunch= false;
  455.     fCommand= cNewGopherFile;
  456. }
  457.  
  458.  
  459. DBinaryGopher::DBinaryGopher(): DGopher()
  460. {
  461.     Initialize();
  462. }
  463.  
  464. DBinaryGopher::DBinaryGopher(DBinaryGopher* aGopher): DGopher(aGopher)
  465. {
  466.     //Initialize();
  467. }
  468.  
  469.  
  470. DBinaryGopher::DBinaryGopher( char ctype, const char* link):
  471.     DGopher( ctype, link)
  472. {
  473.     Initialize();
  474. }
  475.  
  476.  
  477. DObject* DBinaryGopher::Clone()
  478. {
  479.     DBinaryGopher* aGopher= new DBinaryGopher();
  480.     aGopher->CopyGopher( this);
  481.     return aGopher;
  482. }
  483.  
  484.  
  485. void DBinaryGopher::DrawIcon( Nlm_RecT& area, short size)  /* override */ 
  486. {
  487.     gGopherIconID= kBinaryIcon;
  488.     gIconSize= size;
  489.     DrawIconSub( area);
  490. }
  491.  
  492. const char* DBinaryGopher::GetKindName() 
  493. { 
  494.     return "Binary file";
  495. }
  496.  
  497.  
  498.  
  499.  
  500. void DBinaryGopher::OpenQuery()
  501. {
  502.     if (fQueryPlus != NULL)  ;             // if wrapper has set this (for +ASK reply) leave it
  503.     else if (fIsPlus != kGopherPlusYes) fQueryPlus= NULL;
  504.     else fQueryPlus= "\t+"; // gopher+, this form forces server to send data size first
  505.  
  506.     DGopher::OpenQuery();        
  507. }
  508.  
  509. #if GOOBSOLETE
  510. short DBinaryGopher::GopherIt()
  511. {    
  512.     short    result= cNoCommand;
  513.     Boolean FileIsMade= false;
  514.     long chunksize = kReadMaxbuf1; //Min( FreeMem()/2, kReadMaxbuf1);
  515.  
  516.     OpenQuery();        
  517. #if 1
  518.     if (fInfoHandler)
  519.      while (!EndOfMessage()) {
  520.             ReadAChunk( chunksize);
  521.             //(fInfoHandler)(this);
  522.             fInfoHandler->Process();
  523.             }
  524.     else
  525. #endif    
  526.         FileIsMade= ReadToFile( chunksize);
  527.     if (fLaunch) (void) this->LaunchFile();
  528.     CloseQuery();
  529.     return result;
  530. }
  531. #endif  // GOOBSOLETE
  532.  
  533.  
  534.  
  535.  
  536.  
  537. #ifdef WIN_MSWIN
  538. long    DSoundGopher::kMacType = 4333;
  539. long    DSoundGopher::kMacSire = 3334;
  540. #else
  541. long    DSoundGopher::kMacType = 'snd ';
  542. long    DSoundGopher::kMacSire = '    ';
  543. #endif
  544. char * DSoundGopher::kSuffix = ".sound";
  545.  
  546. void DSoundGopher::InitSignature()     
  547. {
  548.     if (gGopherMap) gGopherMap->GetPreferedFiletype("audio/-", kMacType, kMacSire, kSuffix);     
  549. }
  550.  
  551. void DSoundGopher::Initialize()    // override 
  552. {
  553.     //? fType= kTypeSound; 
  554.     fMacType= kMacType; //'snd ';   
  555.     fMacSire= kMacSire; //'    ';
  556.     fTransferType= kTransferBinary; //text/lines or binary or none ?
  557.     fSaveToDisk= true;
  558.     fLaunch= false; //?? true, but how ?
  559.     fCommand= cNewGopherFile;
  560. }
  561.  
  562. DSoundGopher::DSoundGopher(): DBinaryGopher()
  563. {
  564.     Initialize();
  565. }
  566.  
  567. DSoundGopher::DSoundGopher(DSoundGopher* aGopher): DBinaryGopher(aGopher)
  568. {
  569.     //Initialize();
  570. }
  571.  
  572. DSoundGopher::DSoundGopher( char ctype, const char* link):
  573.     DBinaryGopher( ctype, link)
  574. {
  575.     Initialize();
  576. }
  577.  
  578. DObject* DSoundGopher::Clone()
  579. {
  580.     DSoundGopher* aGopher= new DSoundGopher();
  581.     aGopher->CopyGopher( this);
  582.     return aGopher;
  583. }
  584.  
  585. void DSoundGopher::DrawIcon( Nlm_RecT& area, short size)  /* override */ 
  586. {
  587.     gGopherIconID= kSoundIcon;
  588.     gIconSize= size;
  589.     DrawIconSub( area);
  590. }
  591.  
  592. const char* DSoundGopher::GetKindName() 
  593. { 
  594.     return "Sound";
  595. }
  596.  
  597. #if GOOBSOLETE
  598. short DSoundGopher::GopherIt(void) // override 
  599. {
  600.     return DBinaryGopher::GopherIt();
  601. }
  602. #endif  // GOOBSOLETE
  603.  
  604.  
  605.  
  606.  
  607. #ifdef WIN_MSWIN
  608. long    DImageGopher::kMacType = 5555;
  609. long    DImageGopher::kMacSire = 3333;
  610. #else
  611. long    DImageGopher::kMacType = 'GIFf';
  612. long    DImageGopher::kMacSire = 'JVWR';
  613. #endif
  614. char * DImageGopher::kSuffix = ".image";
  615.  
  616. void DImageGopher::InitSignature()     
  617. {
  618.     if (gGopherMap) gGopherMap->GetPreferedFiletype("image/-", kMacType, kMacSire, kSuffix);     
  619. }
  620.  
  621. void DImageGopher::Initialize()    // override 
  622. {
  623.     //? fType= kTypeImage; 
  624.     fMacType= kMacType; //'GIFf';   
  625.     fMacSire= kMacSire; //'Bozo';  
  626.     fTransferType= kTransferBinary; //text/lines or binary or none ?
  627.     fSaveToDisk= true;
  628.     fLaunch= false; 
  629.     fCommand= cNewGopherImage;
  630. }
  631.  
  632. DImageGopher::DImageGopher(): DBinaryGopher()
  633. {
  634.     Initialize();
  635. }
  636.  
  637. DImageGopher::DImageGopher(DImageGopher* aGopher): DBinaryGopher(aGopher)
  638. {
  639.     //Initialize();
  640. }
  641.  
  642. DImageGopher::DImageGopher( char ctype, const char* link):
  643.     DBinaryGopher( ctype, link)
  644. {
  645.     Initialize();
  646. }
  647.  
  648. DObject* DImageGopher::Clone()
  649. {
  650.     DImageGopher* aGopher= new DImageGopher();
  651.     aGopher->CopyGopher( this);
  652.     return aGopher;
  653. }
  654.  
  655. void DImageGopher::DrawIcon( Nlm_RecT& area, short size)  /* override */ 
  656. {
  657.     gGopherIconID= kImageIcon;
  658.     gIconSize= size;
  659.     DrawIconSub( area);
  660. }
  661.  
  662. const char* DImageGopher::GetKindName() 
  663. { 
  664.     return "Image";
  665. }
  666.  
  667. #if GOOBSOLETE
  668. short DImageGopher::GopherIt() // override 
  669. {
  670.     return DBinaryGopher::GopherIt();
  671. }
  672. #endif
  673.  
  674.  
  675.  
  676.  
  677.  
  678. #ifdef WIN_MSWIN
  679. long    DMovieGopher::kMacType = 3322;
  680. long    DMovieGopher::kMacSire = 2233;
  681. #else
  682. long    DMovieGopher::kMacType = 'MooV';
  683. long    DMovieGopher::kMacSire = 'TVOD';
  684. #endif
  685. char * DMovieGopher::kSuffix = ".movie";
  686.  
  687. void DMovieGopher::InitSignature()     
  688. {
  689.     if (gGopherMap) gGopherMap->GetPreferedFiletype("movie/-", kMacType, kMacSire, kSuffix);     
  690. }
  691.  
  692. void DMovieGopher::Initialize()    // override 
  693. {
  694.     //? fType= kTypeMovie; 
  695.     fMacType= kMacType; //'MooV';   
  696.     fMacSire= kMacSire; //'TVOD';   
  697.     fTransferType= kTransferBinary; //text/lines or binary or none ?
  698.     fSaveToDisk= true;
  699.     fLaunch= false; 
  700.     fCommand= cNewGopherFile;
  701. }
  702.  
  703. DMovieGopher::DMovieGopher(): DBinaryGopher()
  704. {
  705.     Initialize();
  706. }
  707.  
  708. DMovieGopher::DMovieGopher(DMovieGopher* aGopher): DBinaryGopher(aGopher)
  709. {
  710.     //Initialize();
  711. }
  712.  
  713. DMovieGopher::DMovieGopher( char ctype, const char* link):
  714.     DBinaryGopher( ctype, link)
  715. {
  716.     Initialize();
  717. }
  718.  
  719. DObject* DMovieGopher::Clone()
  720. {
  721.     DMovieGopher* aGopher= new DMovieGopher();
  722.     aGopher->CopyGopher( this);
  723.     return aGopher;
  724. }
  725.  
  726. void DMovieGopher::DrawIcon( Nlm_RecT& area, short size)  /* override */ 
  727. {
  728.     gGopherIconID= kMovieIcon;
  729.     gIconSize= size;
  730.     DrawIconSub( area);
  731. }
  732.  
  733. const char* DMovieGopher::GetKindName() 
  734. { 
  735.     return "Movie";
  736. }
  737.  
  738. #if GOOBSOLETE
  739. short DMovieGopher::GopherIt() // override 
  740. {
  741.     return DBinaryGopher::GopherIt();
  742. }
  743. #endif
  744.  
  745.  
  746.  
  747. void DNoteGopher::Initialize()    // override 
  748. {
  749.     //? fType= kTypeNote; 
  750. #ifdef WIN_MSWIN
  751. #else
  752.     fMacType= 'TEXT';
  753.     fMacSire= 'Rich';
  754. #endif
  755.     fTransferType= kTransferText;  
  756.     fSaveToDisk= true;
  757.     fLaunch= false; 
  758.     fCommand= cNoCommand;
  759. }
  760.  
  761. DNoteGopher::DNoteGopher(): DGopher()
  762. {
  763.     Initialize();
  764. }
  765.  
  766. DNoteGopher::DNoteGopher(DNoteGopher* aGopher): DGopher(aGopher)
  767. {
  768.     //Initialize();
  769. }
  770.  
  771. DNoteGopher::DNoteGopher( char ctype, const char* link):
  772.     DGopher( ctype, link)
  773. {
  774.     Initialize();
  775. }
  776.  
  777. DObject* DNoteGopher::Clone()
  778. {
  779.     DNoteGopher* aGopher= new DNoteGopher();
  780.     aGopher->CopyGopher( this);
  781.     return aGopher;
  782. }
  783.  
  784. void DNoteGopher::InfoTask() 
  785. {    
  786.     fThreadState= kThreadDoneReading; 
  787. }
  788.  
  789. void DNoteGopher::DrawIcon( Nlm_RecT& area, short size)  /* override */ 
  790. {
  791.     gGopherIconID= kNoteIcon;
  792.     gIconSize= size;
  793.     DrawIconSub( area);
  794. }
  795.  
  796. const char* DNoteGopher::GetKindName() 
  797. { 
  798.     return "Note";
  799. }
  800.  
  801. #if GOOBSOLETE
  802. short DNoteGopher::GopherIt() // override 
  803. {
  804.     return cNoCommand; //DGopher::GopherIt();
  805. }
  806. #endif
  807.  
  808.  
  809.  
  810.  
  811. // DHtmlGopher
  812.  
  813. void DHtmlGopher::Initialize()    // override 
  814. {
  815.     //? fType= kTypeNote; 
  816. #ifdef WIN_MSWIN
  817. #else
  818.     fMacType= 'TEXT';
  819.     fMacSire= 'Rich';
  820. #endif
  821.     fTransferType= kTransferText;  
  822.     fSaveToDisk= false;
  823.     fLaunch= false; 
  824.     fCommand= cNewGopherText;
  825. }
  826.  
  827. DHtmlGopher::DHtmlGopher(): DTextGopher()
  828. {
  829.     Initialize();
  830. }
  831.  
  832. DHtmlGopher::DHtmlGopher(DHtmlGopher* aGopher): DTextGopher(aGopher)
  833. {
  834.     //Initialize();
  835. }
  836.  
  837. DHtmlGopher::DHtmlGopher( char ctype, const char* link):
  838.     DTextGopher( ctype, link)
  839. {
  840.     Initialize();
  841. }
  842.  
  843. DObject* DHtmlGopher::Clone()
  844. {
  845.     DHtmlGopher* aGopher= new DHtmlGopher();
  846.     aGopher->CopyGopher( this);
  847.     return aGopher;
  848. }
  849.  
  850.  
  851. void DHtmlGopher::DrawIcon( Nlm_RecT& area, short size)  /* override */ 
  852. {
  853.     gGopherIconID= kHTMLIcon; 
  854.     gIconSize= size;
  855.     DrawIconSub( area);
  856. }
  857.  
  858. const char* DHtmlGopher::GetKindName() 
  859. { 
  860.     return "HTML document";
  861. }
  862.  
  863.  
  864.  
  865.  
  866. void DMailGopher::Initialize()    // override 
  867. {
  868.     //? fType= kTypeNote; 
  869. #ifdef WIN_MSWIN
  870. #else
  871.     fMacType= 'TEXT';
  872.     fMacSire= 'Rich';
  873. #endif
  874.     fTransferType= kTransferText;  
  875.     fSaveToDisk= true;
  876.     fLaunch= false; 
  877.     //fCommand= cNoCommand;
  878.     fCommand= kGopherTask; // this is wrong, but need something for processing
  879. }
  880.  
  881. DMailGopher::DMailGopher(): DGopher()
  882. {
  883.     Initialize();
  884. }
  885.  
  886. DMailGopher::DMailGopher(DMailGopher* aGopher): DGopher(aGopher)
  887. {
  888.     //Initialize();
  889. }
  890.  
  891. DMailGopher::DMailGopher( char ctype, const char* link):
  892.     DGopher( ctype, link)
  893. {
  894.     Initialize();
  895. }
  896.  
  897. void DMailGopher::InfoTask() 
  898. {    
  899.     fThreadState= kThreadDoneReading; 
  900. }
  901.  
  902.  
  903. void DMailGopher::OpenQuery()
  904. {
  905.     char *mailto= (char*) this->GetPath();
  906.     char *wintitle= (char*)this->ShortName(); //"Mail To";
  907.     DSendMailDialog* win= 
  908.         new DSendMailDialog(0, gApplication, -10, -10, -20, -20, wintitle);
  909.     win->InstallTo(win, mailto);
  910.     win->InstallSubject(win, (char*)this->GetName());
  911.     if (fQueryPlus) win->InstallMessage(win, fQueryPlus);// use this handle for mail message?
  912.     win->Open();
  913.     
  914.     fThreadState= kThreadDoneReading;
  915. }
  916.  
  917. DObject* DMailGopher::Clone()
  918. {
  919.     DMailGopher* aGopher= new DMailGopher();
  920.     aGopher->CopyGopher( this);
  921.     return aGopher;
  922. }
  923.  
  924. void DMailGopher::DrawIcon( Nlm_RecT& area, short size)  /* override */ 
  925. {
  926.     gGopherIconID= kNoteIcon;
  927.     gIconSize= size;
  928.     DrawIconSub( area);
  929. }
  930.  
  931. const char* DMailGopher::GetKindName() 
  932. { 
  933.     return "Mailto";
  934. }
  935.  
  936.  
  937.  
  938.  
  939.  
  940.  
  941. void DHTTPGopher::Initialize()    // override 
  942. {
  943.     //? fType= kTypeNote; 
  944. #ifdef WIN_MSWIN
  945. #else
  946.     fMacType= 'TEXT';
  947.     fMacSire= 'Rich';
  948. #endif
  949.     fTransferType= kTransferText;  
  950.     fProtocol= kHTTPprot;
  951.     fSaveToDisk= true;
  952.     fLaunch= false; 
  953.     //fCommand= cNoCommand;
  954.     fCommand= kGopherTask; // this is wrong, but need something for processing
  955. }
  956.  
  957. DHTTPGopher::DHTTPGopher(): DGopher()
  958. {
  959.     Initialize();
  960. }
  961.  
  962. DHTTPGopher::DHTTPGopher(DHTTPGopher* aGopher): DGopher(aGopher)
  963. {
  964.     //Initialize();
  965. }
  966.  
  967. DHTTPGopher::DHTTPGopher( char ctype, const char* link):
  968.     DGopher( ctype, link)
  969. {
  970.     Initialize();
  971. }
  972.  
  973. void DHTTPGopher::InfoTask() 
  974. {    
  975.     fThreadState= kThreadDoneReading; 
  976. }
  977.  
  978.  
  979. void DHTTPGopher::OpenQuery()
  980. {
  981.     DGopher::OpenQuery();        
  982.     if (fTalker) fTalker->NullTerm(true); //!?
  983.     if (fTransferType == kTransferText 
  984.             && fInfo && fInfoSize>0 && fInfo[fInfoSize] == kLF) 
  985.                 fInfo[fInfoSize--]= 0;  
  986. }
  987.  
  988. DObject* DHTTPGopher::Clone()
  989. {
  990.     DHTTPGopher* aGopher= new DHTTPGopher();
  991.     aGopher->CopyGopher( this);
  992.     return aGopher;
  993. }
  994.  
  995. void DHTTPGopher::DrawIcon( Nlm_RecT& area, short size)  /* override */ 
  996. {
  997.     gGopherIconID= kTextIcon; //kHTTPIcon; // ! want own icon
  998.     gIconSize= size;
  999.     DrawIconSub( area);
  1000. }
  1001.  
  1002. const char* DHTTPGopher::GetKindName() 
  1003. { 
  1004.     return "HTTP link";
  1005. }
  1006.  
  1007.  
  1008.  
  1009.  
  1010.  
  1011.  
  1012. // DBinhexGopher.cp
  1013. //   class to convert HQX encoded data to Mac file
  1014.  
  1015.  
  1016. void DBinhexGopher::Initialize()    // override 
  1017. {
  1018.     //? fType= kTypeBinhex; 
  1019. #ifdef WIN_MSWIN
  1020. #else
  1021.     fMacType= 'TEXT';
  1022.     fMacSire= 'EDIT';
  1023. #endif
  1024.     fTransferType= kTransferBinary;  //< should be okay for binhex translator 
  1025.     fSaveToDisk= true;
  1026.     fLaunch= false; //true; ??
  1027.     fCommand= cNewGopherFile;
  1028.  
  1029.     fHqxbuf= NULL;
  1030. }
  1031.  
  1032. DBinhexGopher::DBinhexGopher(): DGopher()
  1033. {
  1034.     Initialize();
  1035. }
  1036.  
  1037. DBinhexGopher::DBinhexGopher(DBinhexGopher* aGopher): DGopher(aGopher)
  1038. {
  1039.     //Initialize();
  1040.     fHqxbuf= NULL;
  1041. }
  1042.  
  1043. DBinhexGopher::DBinhexGopher( char ctype, const char* link):
  1044.     DGopher( ctype, link)
  1045. {
  1046.     Initialize();
  1047. }
  1048.  
  1049. DObject* DBinhexGopher::Clone()
  1050. {
  1051.     DBinhexGopher* aGopher= new DBinhexGopher();
  1052.     aGopher->CopyGopher( this);
  1053.     return aGopher;
  1054. }
  1055.  
  1056. void DBinhexGopher::DrawIcon( Nlm_RecT& area, short size)  //override 
  1057. {
  1058.     gGopherIconID= kBinhexIcon;
  1059.     gIconSize= size;
  1060.     DrawIconSub( area);
  1061. }
  1062.  
  1063. const char* DBinhexGopher::GetKindName() 
  1064. { 
  1065.     return "Binhex file";
  1066. }
  1067.  
  1068.  
  1069.  
  1070. #ifdef FIX_LATER
  1071.  
  1072. const long kNeedMoreHQXData = -1;
  1073. const long msgMyError = 0x80001234;
  1074.  
  1075.  
  1076. /* from hqxify.c in
  1077.  * mcvert.c - version 1.05 - 10 January, 1990 modified 12 March, 1990 by NP
  1078.  * Written by Doug Moore - Rice University - dougm@rice.edu - April '87
  1079.  */
  1080.  
  1081. //#include "debinhex.h"
  1082. /* debinhex.h -- from mactypes.h of mcvert */
  1083.  
  1084. /* Useful, though not particularly Mac related, values */
  1085. typedef unsigned char byte;     /* one byte, obviously */
  1086. typedef unsigned short word;    /* must be 2 bytes */
  1087. typedef unsigned long ulong;    /* 4 bytes */
  1088. #define CR 0x0d
  1089. #define LF 0x0a
  1090.  
  1091.  
  1092. // mpwc
  1093. #define bcopy(a,b,n)  memcpy(b,a,n)
  1094. #define bzero(p,n)      memset(p, 0, n)     
  1095. #define min(a,b)      (a<b)?a:b
  1096. #define max(a,b)      (a>b)?a:b
  1097.  
  1098.  
  1099. #define NAMELEN 63              /* maximum legal Mac file name length */
  1100. #define BINNAMELEN 68           /* NAMELEN + len(".bin\0") */
  1101.  
  1102. /* Format of a bin file:
  1103. A bin file is composed of 128 byte blocks.  The first block is the
  1104. info_header (see below).  Then comes the data fork, null padded to fill the
  1105. last block.  Then comes the resource fork, padded to fill the last block.  A
  1106. proposal to follow with the text of the Get Info box has not been implemented,
  1107. to the best of my knowledge.  Version, zero1 and zero2 are what the receiving
  1108. program looks at to determine if a MacBinary transfer is being initiated.
  1109. */ 
  1110. typedef struct {     /* info file header (128 bytes). Unfortunately, these
  1111.                         longs don't align to word boundaries */
  1112.             byte version;           /* there is only a version 0 at this time */
  1113.             byte nlen;              /* Length of filename. */
  1114.             byte name[NAMELEN];     /* Filename (only 1st nlen are significant)*/
  1115.             byte type[4];           /* File type. */
  1116.             byte auth[4];           /* File creator. */
  1117.             byte flags;             /* file flags: LkIvBnSyBzByChIt */
  1118.             byte zero1;             /* Locked, Invisible,Bundle, System */
  1119.                                     /* Bozo, Busy, Changed, Init */
  1120.             byte icon_vert[2];      /* Vertical icon position within window */
  1121.             byte icon_horiz[2];     /* Horizontal icon postion in window */
  1122.             byte window_id[2];      /* Window or folder ID. */
  1123.             byte protect;           /* = 1 for protected file, 0 otherwise */
  1124.             byte zero2;
  1125.             byte dlen[4];           /* Data Fork length (bytes) -   most sig.  */
  1126.             byte rlen[4];           /* Resource Fork length         byte first */
  1127.             byte ctim[4];           /* File's creation date. */
  1128.             byte mtim[4];           /* File's "last modified" date. */
  1129.             byte ilen[2];           /* GetInfo message length */
  1130.                         byte flags2;            /* Finder flags, bits 0-7 */
  1131.                         byte unused[14];       
  1132.                         byte packlen[4];        /* length of total files when unpacked */
  1133.                         byte headlen[2];        /* length of secondary header */
  1134.                         byte uploadvers;        /* Version of MacBinary II that the uploading program is written for */
  1135.                         byte readvers;          /* Minimum MacBinary II version needed to read this file */
  1136.                         byte crc[2];            /* CRC of the previous 124 bytes */
  1137.                         byte padding[2];        /* two trailing unused bytes */
  1138.                         } info_header;
  1139.  
  1140. /* The *.info file of a MacTerminal file transfer either has exactly this
  1141. structure or has the protect bit in bit 6 (near the sign bit) of byte zero1.
  1142. The code I have for macbin suggests the difference, but I'm not so sure */
  1143.  
  1144. /* Format of a hqx file:
  1145. It begins with a line that begins "(This file
  1146. and the rest is 64 character lines (except possibly the last, and not
  1147. including newlines) where the first begins and the last ends with a colon.
  1148. The characters between colons should be only from the set in tr86, below,
  1149. each of which corresponds to 6 bits of data.  Once that is translated to
  1150. 8 bit bytes, you have the real data, except that the byte 0x90 may 
  1151. indicate, if the following character is nonzero, that the previous
  1152. byte is to be repeated 1 to 255 times.  The byte 0x90 is represented by
  1153. 0x9000.  The information in the file is the hqx_buf (see below),
  1154. a CRC word, the data fork, a CRC word, the resource fork, and a CRC word.
  1155. There is considerable confusion about the flags.  An official looking document
  1156. unclearly states that the init bit is always clear, as is the following byte.
  1157. The experience of others suggests, however, that this is not the case.
  1158. */
  1159.  
  1160. #define HQXLINELEN 64
  1161. typedef struct {
  1162.             byte version;           /* there is only a version 0 at this time */
  1163.             byte type[4];           /* File type. */
  1164.             byte auth[4];           /* File creator. */
  1165.             byte flags;             /* file flags: LkIvBnSyBzByChIt */
  1166.             byte protect;           /* ?Pr??????, don't know what ? bits mean */
  1167.             byte dlen[4];           /* Data Fork length (bytes) -   most sig.  */
  1168.             byte rlen[4];           /* Resource Fork length         byte first */
  1169.             byte bugblank;             /* to fix obscure sun 3/60 problem
  1170.                                           that always makes sizeof(hqx_header
  1171.                                           even */
  1172.             } hqx_header;
  1173.  
  1174. typedef struct {     /* hqx file header buffer (includes file name) */
  1175.             byte nlen;              /* Length of filename. */
  1176.             byte name[NAMELEN];     /* Filename: only nlen actually appear */
  1177.             hqx_header all_the_rest;/* and all the rest follows immediately */
  1178.             } hqx_buf;
  1179.  
  1180.  
  1181. /* An array useful for CRC calculations that use 0x1021 as the "seed" */
  1182. static unsigned short gMagicCRC[] = {
  1183.     0x0000,  0x1021,  0x2042,  0x3063,  0x4084,  0x50a5,  0x60c6,  0x70e7,
  1184.     0x8108,  0x9129,  0xa14a,  0xb16b,  0xc18c,  0xd1ad,  0xe1ce,  0xf1ef,
  1185.     0x1231,  0x0210,  0x3273,  0x2252,  0x52b5,  0x4294,  0x72f7,  0x62d6,
  1186.     0x9339,  0x8318,  0xb37b,  0xa35a,  0xd3bd,  0xc39c,  0xf3ff,  0xe3de,
  1187.     0x2462,  0x3443,  0x0420,  0x1401,  0x64e6,  0x74c7,  0x44a4,  0x5485,
  1188.     0xa56a,  0xb54b,  0x8528,  0x9509,  0xe5ee,  0xf5cf,  0xc5ac,  0xd58d,
  1189.     0x3653,  0x2672,  0x1611,  0x0630,  0x76d7,  0x66f6,  0x5695,  0x46b4,
  1190.     0xb75b,  0xa77a,  0x9719,  0x8738,  0xf7df,  0xe7fe,  0xd79d,  0xc7bc,
  1191.     0x48c4,  0x58e5,  0x6886,  0x78a7,  0x0840,  0x1861,  0x2802,  0x3823,
  1192.     0xc9cc,  0xd9ed,  0xe98e,  0xf9af,  0x8948,  0x9969,  0xa90a,  0xb92b,
  1193.     0x5af5,  0x4ad4,  0x7ab7,  0x6a96,  0x1a71,  0x0a50,  0x3a33,  0x2a12,
  1194.     0xdbfd,  0xcbdc,  0xfbbf,  0xeb9e,  0x9b79,  0x8b58,  0xbb3b,  0xab1a,
  1195.     0x6ca6,  0x7c87,  0x4ce4,  0x5cc5,  0x2c22,  0x3c03,  0x0c60,  0x1c41,
  1196.     0xedae,  0xfd8f,  0xcdec,  0xddcd,  0xad2a,  0xbd0b,  0x8d68,  0x9d49,
  1197.     0x7e97,  0x6eb6,  0x5ed5,  0x4ef4,  0x3e13,  0x2e32,  0x1e51,  0x0e70,
  1198.     0xff9f,  0xefbe,  0xdfdd,  0xcffc,  0xbf1b,  0xaf3a,  0x9f59,  0x8f78,
  1199.     0x9188,  0x81a9,  0xb1ca,  0xa1eb,  0xd10c,  0xc12d,  0xf14e,  0xe16f,
  1200.     0x1080,  0x00a1,  0x30c2,  0x20e3,  0x5004,  0x4025,  0x7046,  0x6067,
  1201.     0x83b9,  0x9398,  0xa3fb,  0xb3da,  0xc33d,  0xd31c,  0xe37f,  0xf35e,
  1202.     0x02b1,  0x1290,  0x22f3,  0x32d2,  0x4235,  0x5214,  0x6277,  0x7256,
  1203.     0xb5ea,  0xa5cb,  0x95a8,  0x8589,  0xf56e,  0xe54f,  0xd52c,  0xc50d,
  1204.     0x34e2,  0x24c3,  0x14a0,  0x0481,  0x7466,  0x6447,  0x5424,  0x4405,
  1205.     0xa7db,  0xb7fa,  0x8799,  0x97b8,  0xe75f,  0xf77e,  0xc71d,  0xd73c,
  1206.     0x26d3,  0x36f2,  0x0691,  0x16b0,  0x6657,  0x7676,  0x4615,  0x5634,
  1207.     0xd94c,  0xc96d,  0xf90e,  0xe92f,  0x99c8,  0x89e9,  0xb98a,  0xa9ab,
  1208.     0x5844,  0x4865,  0x7806,  0x6827,  0x18c0,  0x08e1,  0x3882,  0x28a3,
  1209.     0xcb7d,  0xdb5c,  0xeb3f,  0xfb1e,  0x8bf9,  0x9bd8,  0xabbb,  0xbb9a,
  1210.     0x4a75,  0x5a54,  0x6a37,  0x7a16,  0x0af1,  0x1ad0,  0x2ab3,  0x3a92,
  1211.     0xfd2e,  0xed0f,  0xdd6c,  0xcd4d,  0xbdaa,  0xad8b,  0x9de8,  0x8dc9,
  1212.     0x7c26,  0x6c07,  0x5c64,  0x4c45,  0x3ca2,  0x2c83,  0x1ce0,  0x0cc1,
  1213.     0xef1f,  0xff3e,  0xcf5d,  0xdf7c,  0xaf9b,  0xbfba,  0x8fd9,  0x9ff8,
  1214.     0x6e17,  0x7e36,  0x4e55,  0x5e74,  0x2e93,  0x3eb2,  0x0ed1,  0x1ef0
  1215.     };
  1216.  
  1217.  
  1218. /* Essentials for Binhex 8to6 run length encoding */
  1219. #define RUNCHAR 0x90
  1220. #define MAXRUN 255
  1221. #define IS_LEGAL <0x40
  1222. #define ISNT_LEGAL >0x3f
  1223. #define DONE 0x7F         /* gTrans68[':'] = DONE, since Binhex terminator is ':' */
  1224. #define SKIP 0x7E         /* gTrans68['\n'|'\r'] = SKIP, i. e. end of line char.  */
  1225. #define FAIL 0x7D         /* character illegal in binhex file */
  1226. #define NULLTERM 0x7C /* end of buffer -- need to read more */
  1227.  
  1228. //static byte tr86[] =
  1229. //        "!\"#$%&'()*+,-012345689@ABCDEFGHIJKLMNPQRSTUVXYZ[`abcdefhijklmpqr"; 
  1230.         
  1231. static byte gTrans68[] = {
  1232.     NULLTERM, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  1233.     FAIL, FAIL, SKIP, FAIL, FAIL, SKIP, FAIL, FAIL,
  1234.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  1235.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  1236.     FAIL, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
  1237.     0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, FAIL, FAIL,
  1238.     0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, FAIL,
  1239.     0x14, 0x15, DONE, FAIL, FAIL, FAIL, FAIL, FAIL,
  1240.     0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,
  1241.     0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, FAIL,
  1242.     0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, FAIL,
  1243.     0x2C, 0x2D, 0x2E, 0x2F, FAIL, FAIL, FAIL, FAIL,
  1244.     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, FAIL,
  1245.     0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, FAIL, FAIL,
  1246.     0x3D, 0x3E, 0x3F, FAIL, FAIL, FAIL, FAIL, FAIL,
  1247.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  1248.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  1249.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  1250.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  1251.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  1252.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  1253.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  1254.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  1255.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  1256.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  1257.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  1258.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  1259.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  1260.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  1261.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  1262.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  1263.     FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
  1264.     };
  1265.  
  1266.  
  1267. #define READING 0
  1268. #define SKIPPING 1
  1269. #define FIND_START_COLON 2
  1270.  
  1271. #define    CRCERROR 1
  1272. #define READERR -1
  1273. #define BINHEX_KEY    "must be converted with BinHex"
  1274.  
  1275. const long     kHqxMaxChunk = kReadMaxbuf1;
  1276. const long  HQXBUFLEN= kHqxMaxChunk;
  1277.  
  1278. #endif // FIX_LATER
  1279.  
  1280.  
  1281.  
  1282. void DBinhexGopher::hqxFini()
  1283. {
  1284. #ifdef FIX_LATER
  1285.     fHqxbuf= (byte*) MemFree( (Ptr)fHqxbuf);
  1286. #endif // FIX_LATER
  1287. }
  1288.  
  1289. void DBinhexGopher::hqxInit() /* call before each hqx file is processed */
  1290. {
  1291. #ifdef FIX_LATER
  1292.     fDecodeStatus = FIND_START_COLON;
  1293.     fHqxbuf= (byte*) MemGet( HQXBUFLEN+1, true);
  1294.     fBufptr= fBufstart= fHqxbuf+1;
  1295.     fBufend= fBufstart + HQXBUFLEN;
  1296.  
  1297.     //fLine= NewPtrClear(MAXLINE+1);
  1298.     //fLinestart= fLine+1;
  1299.     //fLineend= fLinestart + MAXLINE;
  1300.     //fLineptr = fLinestart;
  1301.     //fLineptr[0] = SKIP;
  1302.     
  1303.     fLinecount= 0; //fInoffset = 0; // need to rename this field
  1304.     
  1305.     fTotalbytes = 0;
  1306.     fSavestate = 0;
  1307.     fSaveRunLength = 0;
  1308.     fGotBinhexKey = false;
  1309.  
  1310.     if (fTalker) fTalker->NullTerm( true);  
  1311.     ReadAChunk( kHqxMaxChunk);    
  1312. #endif     // FIX_LATER
  1313. }
  1314.  
  1315.  
  1316. short DBinhexGopher::fill_hqxbuf()
  1317. {   
  1318. #ifdef FIX_LATER
  1319.     register unsigned long c, nibble;
  1320.     register int         not_in_a_run = true, state68;
  1321.     register byte        *inptr, *outptr, *bp;
  1322.     byte                         *instart, *inend, *outend;
  1323.     Boolean                 okay;
  1324.     SignedByte            savedState;    
  1325.  
  1326.     if (!fInfo) return false; // make sure fInfo has data before this
  1327.     savedState = LockHandleHigh(fInfo);  
  1328.     instart= (byte*) *fInfo;
  1329.     inptr= instart + fLinecount; //fInoffset;
  1330.     inend= instart + GetHandleSize( fInfo) - 1;
  1331.     okay= true; //(instart < inend);
  1332.  
  1333.     while (!fGotBinhexKey && okay) {
  1334.         c = 0;
  1335.         while (inptr < inend  && !(*inptr == ':' && (c == kCR || c == kLF))) 
  1336.              c= *inptr++; 
  1337.  
  1338.         if (inptr >= inend) {
  1339.                 // need to expand fInfo, not replace it
  1340.             HUnlock(fInfo);
  1341.             if (*inend == 0) SetHandleSize(fInfo, GetHandleSize( fInfo) - 1); // drop null
  1342.             ReadAChunk( kHqxMaxChunk); 
  1343.             HLock( fInfo);
  1344.             long temp= inptr - instart;
  1345.             instart= (byte*) *fInfo;
  1346.             inptr= instart + temp;
  1347.             byte* tmp1= instart + GetHandleSize( fInfo) - 1;
  1348.             okay = (tmp1 > inend);
  1349.             inend= tmp1;
  1350.             }
  1351.             
  1352.         else { // found key char
  1353.             char* keyptr= (char*) Max( (long)instart, (long)inptr - 82);
  1354.             keyptr= strstr( keyptr, BINHEX_KEY);
  1355.             inptr++; // skip start colon
  1356.             if (keyptr) {
  1357.                 fGotBinhexKey= true;
  1358.                 for (bp= inptr; bp <= inend; bp++) *bp = gTrans68[*bp]; // translate current inputs
  1359.                 }
  1360.             }         
  1361.         }
  1362.     if (!okay) return false; // ran out of input before found start of valid data
  1363.         
  1364.     fDecodeStatus = READING;
  1365.     outptr= fBufptr= fBufstart;
  1366.     outend= fBufend= fBufstart + HQXBUFLEN;
  1367.     state68 = fSavestate;
  1368.     nibble  = fSaveNibble;
  1369.     if (fSaveRunLength > 0) {
  1370.         c = fSaveRunLength;
  1371.         fSaveRunLength = 0;
  1372.         goto continue_run;
  1373.         }
  1374.  
  1375.     while (okay && outptr < outend) {
  1376.  
  1377. next_char:    
  1378.  
  1379.         if (inptr >= inend) { // (?? || c == NULLTERM)
  1380.             //read & translate data
  1381.             HUnlock(fInfo);
  1382.             SetHandleSize(fInfo, 0); // no need to save old inputs
  1383.             ReadAChunk( kHqxMaxChunk); // sticks null at end of read?!
  1384.             if (!fInfo || GetHandleSize(fInfo)<2) { okay= false;  goto data_end; } //out of data
  1385.             HLock( fInfo);
  1386.             inptr= instart= bp= (byte*) *fInfo;
  1387.             inend= instart + GetHandleSize( fInfo) - 1;
  1388.             //while ((*bp = gTrans68[*bp]) IS_LEGAL) bp++;
  1389.             for (bp= inptr; bp <= inend; bp++) *bp = gTrans68[*bp];
  1390.             }
  1391.  
  1392.       c = *inptr++;
  1393.         
  1394.       if (c ISNT_LEGAL) {
  1395.             if (c == DONE) { //kStartOrEnd
  1396.                 fDecodeStatus = READING; //??
  1397.                 okay= false;
  1398.                 }
  1399.             else if (c == NULLTERM) {
  1400.                 //read & translate chunk
  1401.                 //this should be handled by (inptr >= inend)
  1402.                 }
  1403.             else if (c == SKIP) {
  1404.                 // newline
  1405.                 }
  1406.             }
  1407.             
  1408.         else { // (c IS_LEGAL) 
  1409.             if (fDecodeStatus == READING) {
  1410.                 //nibble c;
  1411.                 //stuff c into buf;
  1412.                 //outptr++;
  1413.                 
  1414.         switch (state68++) {
  1415.         case 0:
  1416.             nibble = c;
  1417.             goto next_char;
  1418.         case 1:
  1419.             nibble = (nibble << 6) | c;
  1420.             c = nibble >> 4;
  1421.             break;
  1422.         case 2:
  1423.             nibble = (nibble << 6) | c;
  1424.             c = (nibble >> 2) & 0xff;
  1425.             break;
  1426.         case 3:
  1427.             c = (nibble << 6) & 0xff | c;
  1428.             state68 = 0;
  1429.             break;
  1430.             }
  1431.                         
  1432.         if (not_in_a_run)
  1433.             if (c != RUNCHAR) *outptr++ = c;
  1434.             else {not_in_a_run = false; goto next_char;}
  1435.         else {
  1436.             if (c--) {
  1437.                 not_in_a_run = outend - outptr;
  1438.                 if (c > not_in_a_run) {
  1439.                     fSaveRunLength = c - not_in_a_run;
  1440.                     c = not_in_a_run;
  1441.                     }
  1442.                 continue_run:
  1443.                 not_in_a_run = outptr[-1];
  1444.                 while (c--) *outptr++ = not_in_a_run;
  1445.                 }
  1446.             else *outptr++ = RUNCHAR;
  1447.             not_in_a_run = true;
  1448.             }
  1449.  
  1450.                 }
  1451.                 
  1452.             else if (fDecodeStatus == SKIPPING) {
  1453.                 //???
  1454.                 }
  1455.             
  1456.             }
  1457.         }    
  1458.         
  1459. data_end:
  1460.     fLinecount = inptr - instart; //fInoffset  // save offset from start of fInfo of our move to fHqxbuf
  1461.     if (outptr < outend) fBufend= outptr;
  1462.     fTotalbytes += fBufend - fBufptr; // don't need, dups fBytesread
  1463.     fBufstart[-1] = outptr[-1]; //?? what is this, saving some data b/n calls?
  1464.     fSavestate = state68;
  1465.     fSaveNibble = nibble;
  1466.     HSetState( fInfo, savedState);
  1467.     return (fBufptr < fBufend);
  1468. #endif // FIX_LATER
  1469.     return 0;
  1470. }
  1471.  
  1472.  
  1473. long DBinhexGopher::check_hqx_crc()
  1474. {   
  1475. #ifdef FIX_LATER
  1476.         word read_crc;
  1477.         
  1478.     if (fBufptr >= fBufend) { if (fill_hqxbuf() == false) return READERR;  }
  1479.     read_crc  = *fBufptr++ << 8;
  1480.     if (fBufptr >= fBufend) { if (fill_hqxbuf() == false) return READERR;  }
  1481.     read_crc |= *fBufptr++;
  1482.         return read_crc;
  1483. #endif // FIX_LATER
  1484.     return 0;
  1485. }
  1486.  
  1487. /* This routine reads the header of a hqxed file and appropriately twiddles it,
  1488.     determines if it has CRC problems & returns needed Mac file info */
  1489.  
  1490. short DBinhexGopher::hqx2FinderInfo( char *binfname, long *fauth, long *ftype, 
  1491.                                         unsigned long *hqx_datalen, unsigned long  *hqx_rsrclen) 
  1492. {   
  1493. #ifdef FIX_LATER
  1494.         register byte *hqx_ptr, *hqx_end;
  1495.     register ulong calc_crc;
  1496.         word                hqx_crc;
  1497.         int                    len;
  1498.     hqx_buf         *hqx_block;
  1499.     hqx_header     *hqx;
  1500.  
  1501.     /* read the hqx header, assuming that I won't exhaust hqxbuf in so doing */
  1502.         if (fill_hqxbuf() == false) return READERR;
  1503.         
  1504.     hqx_block = (hqx_buf *) fBufptr;
  1505.       hqx = (hqx_header *) (hqx_block->name + hqx_block->nlen); 
  1506.     hqx_ptr = fBufptr;
  1507.     hqx_end = (byte *) hqx + sizeof(hqx_header) - 1;
  1508.     calc_crc = 0;
  1509.     while (hqx_ptr < hqx_end)
  1510.         calc_crc = (((calc_crc&0xff) << 8) | *hqx_ptr++) ^ gMagicCRC[calc_crc >> 8];
  1511.     calc_crc = ((calc_crc&0xff) << 8) ^ gMagicCRC[calc_crc >> 8];
  1512.     calc_crc = ((calc_crc&0xff) << 8) ^ gMagicCRC[calc_crc >> 8];
  1513.     fBufptr = hqx_ptr;
  1514.  
  1515.         len= min( BINNAMELEN-1, hqx_block->nlen);
  1516.     strncpy( binfname, (char*)hqx_block->name, len);  
  1517.         binfname[len]= 0;
  1518.         bcopy( hqx->auth, fauth, 4);
  1519.         bcopy( hqx->type, ftype, 4);
  1520.     bcopy( hqx->dlen, hqx_datalen, 4);         
  1521.     bcopy( hqx->rlen, hqx_rsrclen, 4);         
  1522.  
  1523.         hqx_crc= check_hqx_crc();
  1524.         if (hqx_crc == (word) calc_crc) return 0;
  1525.         else return CRCERROR;
  1526. #endif    // FIX_LATER
  1527.     return 0;
  1528. }
  1529.  
  1530.  
  1531. /* This routine copies bytes from the decoded input stream to the output. */
  1532.         
  1533. short DBinhexGopher::hqx2fork( short fileref, unsigned long nbytes) 
  1534. {   
  1535. #ifdef FIX_LATER
  1536.         register byte *c;
  1537.     register ulong calc_crc;
  1538.     register ulong c_length;
  1539.         word    hqx_crc;
  1540.         long    buflen;
  1541.  
  1542.     calc_crc = 0;
  1543.     for (;;) {
  1544.         c = fBufptr;
  1545.         buflen = c_length = (c + nbytes > fBufend) ? fBufend - c : nbytes;
  1546.         nbytes -= c_length;
  1547.                 (void) FSWrite( fileref, &buflen, c); 
  1548.                 
  1549.         while (c_length--)
  1550.             calc_crc = (((calc_crc&0xff) << 8) | *c++) ^ gMagicCRC[calc_crc >> 8];
  1551.         if (!nbytes) break;
  1552.                 if (fill_hqxbuf() == false) return READERR;
  1553.         }
  1554.     fBufptr = c;
  1555.     calc_crc = ((calc_crc&0xff) << 8) ^ gMagicCRC[calc_crc >> 8];
  1556.     calc_crc = ((calc_crc&0xff) << 8) ^ gMagicCRC[calc_crc >> 8];
  1557.  
  1558.         hqx_crc= check_hqx_crc();
  1559.     if (hqx_crc == (word) calc_crc) return 0;
  1560.         else return CRCERROR;
  1561. #endif    // FIX_LATER
  1562.     return 0;
  1563. }
  1564.  
  1565.  
  1566.  
  1567. #if GOOBSOLETE
  1568. short DBinhexGopher::GopherIt() // override 
  1569. {    
  1570. #ifdef FIX_LATER
  1571.     short        err,i, fileRef, volRefnum;
  1572.     unsigned long        hqxdatalen, hqxrsrclen;
  1573.     long    fileAuth, fileType;
  1574.     CStr255    fileName;
  1575.     FailInfo    fi;
  1576.     SFReply    reply;
  1577.     Boolean FileIsMade= false;
  1578.  
  1579.     //short saveIsPlus = fIsPlus;
  1580.     //fIsPlus= kGopherPlusNo; // god damn stupid ass bug what the fuck is going on here
  1581.     
  1582.     if (fQueryPlus != NULL)  ;             // if wrapper has set this (for +ASK reply) leave it
  1583.     else if (fIsPlus != kGopherPlusYes) fQueryPlus= NULL;
  1584.     else fQueryPlus= "\t+"; // gopher+, this form forces server to send data size first
  1585.     
  1586.     if (fi.Try()) {
  1587.         OpenQuery();        
  1588.  
  1589.         //if (fTalker->CharsAvailable() == 0) 
  1590.         //    fTalker->ShowMessage("TCP connection timed out");  
  1591.         //else 
  1592.         {
  1593.             if (fTalker) fTalker->ShowMessage("Gopher is digging for data");
  1594.             fileName[1]= 0;
  1595.             
  1596.             hqxInit(); 
  1597.             err= hqx2FinderInfo( (char*)&fileName[1], &fileAuth, &fileType, 
  1598.                                                             &hqxdatalen, &hqxrsrclen);    
  1599.             for (i= 1;  (i<80) && (fileName[i]!=0); i++) ;
  1600.             fileName[0]= i-1;
  1601.         
  1602.             if (fTalker) fTalker->ShowMessage( "Found Binhex file "+fileName);
  1603.             FailOSErr( err); //?
  1604.     
  1605.             // file put dialog: where to save, or cancel...
  1606.             if (gUseDigFolder || !BringAppFrontmost( 0)) {
  1607.                 memcpy(reply.fName, (unsigned char*)fileName, 1+fileName[0]); //reply.fName= fileName;
  1608.                 reply.good= true;  
  1609.                 err= OpenWD( gDigVol, gDigDirID, 0, &reply.vRefNum);
  1610.                 }        
  1611.             else {
  1612.                 CPoint        where;
  1613.                 CenterSFPut( where);
  1614.                 SFPutFile( where,  CStr31("Save fetched file as:"), fileName, NULL, &reply);
  1615.                 gApplication->UpdateAllWindows();
  1616.                 }
  1617.             
  1618.             if (reply.good) {
  1619.                 fileName = reply.fName;
  1620.                 volRefnum = reply.vRefNum;
  1621.                 (void) FSDelete( fileName, volRefnum) ;
  1622.                 FailOSErr( Create( fileName, volRefnum, fileAuth, fileType));
  1623.                 FileIsMade= true;
  1624.                 
  1625.                 if (hqxdatalen>0) {        // data fork
  1626.                     FailOSErr( FSOpen( fileName, volRefnum, &fileRef));
  1627.                     if (fTalker) fTalker->ShowMessage("Reading data fork");
  1628.                     err= hqx2fork( fileRef, hqxdatalen);
  1629.                     (void) FSClose( fileRef);
  1630.                     FailOSErr( err);
  1631.                     }
  1632.                 
  1633.                 if (hqxrsrclen>0) {
  1634.                     FailOSErr( OpenRF( fileName, volRefnum, &fileRef));
  1635.                     if (fTalker) fTalker->ShowMessage("Reading rsrc fork");
  1636.                     err= hqx2fork( fileRef, hqxrsrclen);
  1637.                     (void) FSClose( fileRef);
  1638.                     if (hqxrsrclen > 0) FailOSErr( err); 
  1639.                     }
  1640.                 
  1641.                 // AppFile *pFile = new Appfile;
  1642.                 AppFile    theFile;
  1643.                 DisposeIfHandle( fAppFile);
  1644.                 FailNIL(fAppFile = NewHandle(sizeof(AppFile)));
  1645.                 theFile.vRefNum= volRefnum;  
  1646.                 theFile.fType= fileType;
  1647.                 //theFile.fName= fileName;
  1648.                 memcpy( theFile.fName, &fileName[0], 1+fileName[0]);
  1649.                 memcpy( *fAppFile, &theFile, sizeof(AppFile));
  1650.  
  1651.                 if (fLaunch) (void) this->LaunchFile();
  1652.                 }
  1653.             }
  1654.  
  1655.         hqxFini(); 
  1656.         fi.Success();
  1657.         CloseQuery();
  1658.         }
  1659.     else { // fail
  1660.         hqxFini(); 
  1661.         CloseQuery();
  1662.         if (FileIsMade) (void) FSDelete( fileName, volRefnum);
  1663.         fi.ReSignal();    
  1664.         }
  1665.  
  1666.     //fIsPlus=     saveIsPlus;
  1667. #endif    // FIX_LATER
  1668.     return cNoCommand;
  1669. }
  1670. #endif
  1671.  
  1672.  
  1673.  
  1674.  
  1675.  
  1676.  
  1677. const short kGopherOkayID    = 2206;    // dialog window for messages 
  1678.  
  1679.  
  1680. void DTelnetGopher::Initialize()    // override 
  1681. {
  1682.     //? fType= kTypeTelnet; 
  1683. #ifdef WIN_MSWIN
  1684. #else
  1685.     fMacType= 'CONF';
  1686.     fMacSire= 'NCSA';
  1687. #endif
  1688.     fTransferType= kTransferText; //text/lines or binary or none ?
  1689.     fSaveToDisk= true;
  1690.     fLaunch= true;
  1691.     fCommand= cNewGopherFile;
  1692. }
  1693.  
  1694. DTelnetGopher::DTelnetGopher(): DGopher()
  1695. {
  1696.     Initialize();
  1697. }
  1698.  
  1699. DTelnetGopher::DTelnetGopher(DTelnetGopher* aGopher): DGopher(aGopher)
  1700. {
  1701.     //Initialize();
  1702. }
  1703.  
  1704. DTelnetGopher::DTelnetGopher( char ctype, const char* link):
  1705.     DGopher( ctype, link)
  1706. {
  1707.     Initialize();
  1708. }
  1709.  
  1710. DObject* DTelnetGopher::Clone()
  1711. {
  1712.     DTelnetGopher* aGopher= new DTelnetGopher();
  1713.     aGopher->CopyGopher( this);
  1714.     return aGopher;
  1715. }
  1716.  
  1717. void DTelnetGopher::InfoTask() 
  1718. {    
  1719.     fThreadState= kThreadDoneReading; 
  1720. }
  1721.  
  1722.  
  1723. void DTelnetGopher::DrawIcon( Nlm_RecT& area, short size)  /* override */ 
  1724. {
  1725.     gGopherIconID= kTelnetIcon;
  1726.     gIconSize= size;
  1727.     DrawIconSub( area);
  1728. }
  1729.  
  1730. const char* DTelnetGopher::GetKindName() 
  1731. { 
  1732.     return "Telnet session";
  1733. }
  1734.  
  1735. void DTelnetGopher::promptUser(char* msg1, char* msg2)
  1736. {
  1737. #ifdef FIX_LATER
  1738.     TWindow *aWind = (TWindow *)gViewServer->NewTemplateWindow(kGopherOkayID, NULL);
  1739.     FailNIL( aWind);          
  1740.     TStaticText    *aTitle = (TStaticText*) aWind->FindSubView('msg1');
  1741.     if (aTitle!=NULL) aTitle->SetText( msg1, kDontRedraw);
  1742.     aTitle = (TStaticText*) aWind->FindSubView('msg2');
  1743.     if (aTitle!=NULL) aTitle->SetText( msg2, kDontRedraw);
  1744.     //TDialogView    *aDlog = (TDialogView*) aWind->FindSubView('DLOG');
  1745.     aWind->SetModality( true); //PoseModally will fail !!
  1746.     IDType dismisser = aWind->PoseModally();
  1747.     //if (dismisser == 'OKAY') ;
  1748.     aWind->CloseAndFree(); 
  1749.     gApplication->UpdateAllWindows();
  1750. #endif    // FIX_LATER
  1751. }
  1752.  
  1753.  
  1754. #if GOOBSOLETE
  1755. short DTelnetGopher::GopherIt() // override 
  1756. /*---- 
  1757. Example Telnet gopher links:
  1758. Name=CUline, University of Colorado,Boulder
  1759. Type=8
  1760. Port=852
  1761. Path=
  1762. Host=culine.Colorado.EDU
  1763.  
  1764. Name=Columbia University
  1765. Type=8
  1766. Port=0
  1767. Path=calendar  << account name to log on as ...
  1768. Host=cal.cc.columbia.edu
  1769. ------*/
  1770. {
  1771. #ifdef FIX_LATER
  1772.     short            i, fileRef, vRefNum;
  1773.     long            dirID;
  1774.     CPoint        where;
  1775.     SFReply        reply;
  1776.     Boolean        okay, hasSystem7;
  1777.     CStr255        msg1, msg2;
  1778. #define          fileName    msg1
  1779.     CStr255     myName= this->GetName();
  1780.     CStr255     myHost= this->GetHost();
  1781.     
  1782.     fileName= myName;  
  1783.     if (fileName.Length() > 31) fileName[0]= 31;
  1784.     for (i= 1; i<= fileName.Length(); i++) if (fileName[i] == ':') fileName[i]= '-';
  1785.     dirID= 0;
  1786.     vRefNum= 0;
  1787.     okay= false;
  1788.     
  1789.     fThreadState= kThreadDoneReading; // this method doesn't read tcp directly
  1790.     
  1791.     if (gUseDigFolder) {
  1792.         vRefNum= gDigVol;
  1793.         dirID= gDigDirID;
  1794.         okay= true;  
  1795.         }
  1796.     /*****        
  1797.     else if (GestaltFlag( gestaltFindFolderAttr, gestaltFindFolderPresent)) {
  1798.         //! can't use kTemporaryFolderType == app can't find files there
  1799.         okay= noErr == FindFolder(kOnSystemDisk,kPreferencesFolderType, 
  1800.                                                                     kCreateFolder,vRefNum,dirID);
  1801.         }
  1802.     *****/
  1803.     
  1804.     if (!okay) {
  1805.         if (!BringAppFrontmost( 0)) {
  1806.             okay= true;
  1807.             vRefNum= gDigVol;
  1808.             dirID= gDigDirID;
  1809.             }        
  1810.         else {
  1811.             CenterSFPut( where);
  1812.             SFPutFile( where, CStr31("Save Telnet session as:"), fileName, NULL, &reply);
  1813.             gApplication->UpdateAllWindows();
  1814.             if (reply.good) {
  1815.                 memcpy((unsigned char*)fileName, reply.fName, 1+reply.fName[0]); //fileName = reply.fName;
  1816.                 vRefNum  = reply.vRefNum;
  1817.                 okay= true;
  1818.                 }
  1819.             }
  1820.         }
  1821.     
  1822.     if (okay) {
  1823.         unsigned int  bufmax = 300 + myName.Length() + myHost.Length();
  1824.         char* buf= (char*) malloc( bufmax);
  1825.         char* cp= buf;
  1826.         sprintf( cp, "name=\"%s\"\n", (char*)myName);  cp += strlen(cp);
  1827.         sprintf( cp, "host=\"%s", (char*)myHost); cp += strlen(cp);
  1828.         if (fPort != 0) { sprintf( cp, " %d", fPort); cp += strlen(cp);}
  1829.         sprintf( cp, "\"\n\0"); cp += strlen(cp);
  1830.         long buflen= strlen( buf);
  1831.         
  1832.         if (0 != HDelete( vRefNum, dirID, fileName)) ;
  1833.         FailOSErr( HCreate( vRefNum, dirID, fileName, fMacSire, fMacType));
  1834.         FailOSErr( HOpen( vRefNum, dirID, fileName, fsWrPerm, &fileRef));
  1835.         FailOSErr( FSWrite( fileRef, &buflen, buf)); 
  1836.         FailOSErr( FSClose( fileRef));
  1837.         free( buf);
  1838.         
  1839.         if (fLaunch && gHasAppleEvents) 
  1840.             hasSystem7= (noErr == LaunchFileThruFinder(vRefNum, dirID, fileName));
  1841.         else
  1842.             hasSystem7= false;
  1843.             
  1844.         if (hasSystem7) msg1= "";
  1845.         else msg1= "To use, launch the telnet session file '" + fileName + "'";
  1846.         //if ( *(*fLink+fIpath)  == 0) msg2= "";
  1847.         if (this->GetPath().Length() == 0) msg2= "";
  1848.         else msg2= "At the telnet login/username prompt, log on as '" 
  1849.                                 + this->GetPath() + CStr31("'");
  1850.         if (!msg1.IsEmpty() || !msg2.IsEmpty()) promptUser(msg1, msg2);
  1851.  
  1852.         //delete temp file...can we do it yet? must be sure finder has launched...
  1853.         //- if (hasSystem7) if (0!=HDelete( vRefNum, dirID, fileName)) ; 
  1854.         // what we really need is a list of garbage/temp files to delete on quitting
  1855.         //    program... include childApp temp files
  1856.         }
  1857.         
  1858.     //SetString( gGopherTitle, myName); 
  1859.     //gGopherData= NULL;
  1860. #endif    // FIX_LATER
  1861.  
  1862.     return cNoCommand;
  1863. }
  1864. #endif // GOOBSOLETE
  1865.  
  1866.  
  1867.  
  1868.  
  1869.  
  1870.  
  1871. #ifdef FIX_LATER
  1872. const short kGopherPhoneID    = 2207;    // dialog window for search query 
  1873.  
  1874. void CCSOPhoneBookGopher::addToInfo( char *cp, short len)
  1875. {
  1876.     Handle h= fInfo;
  1877.     if (h==NULL) FailOSErr( PtrToHand( cp, &h, len));
  1878.     else FailOSErr( PtrAndHand( cp, h, len));
  1879.     if ( cp[len-1] != chRtn ) FailOSErr( PtrAndHand( &chRtn, h, 1));
  1880.     fInfo= h;
  1881. }
  1882.  
  1883.  
  1884.  
  1885. void CCSOPhoneBookGopher::ReadALine() 
  1886. {
  1887.         CStr255        aStr; 
  1888.         char        **data;
  1889.  
  1890.     if (fTalker && fTalker->ReadALine( NULL, data)) {
  1891.         switch (**data) {
  1892.             case '2': if (fTalker) fTalker->SetEndOfMessage(true); break;
  1893.             case '3':
  1894.             case '4':
  1895.             case '5':
  1896.             case '6':
  1897.             case '7':
  1898.             case '8':
  1899.             case '9':  
  1900.                     fTalker->SetEndOfMessage(true);
  1901.                     addToInfo( (*fLink+fIpath), (short)strlen(*fLink+fIpath));
  1902.                     addToInfo( *data + 4, (short) GetHandleSize( data)-4);
  1903.                     break;
  1904.             case '-':  
  1905.                     if (fTalker) fTalker->SetEndOfMessage(false);
  1906.                     addToInfo( *data+7, (short) GetHandleSize( data)-7);
  1907.                     break;
  1908.             }
  1909.         }
  1910. }
  1911.  
  1912.  
  1913. void CCSOPhoneBookGopher::ReadAChunk( long maxchunk) // override  
  1914. {
  1915.     Boolean tooBig;
  1916.     //!! need to read by lines to parse CSO, ? use Inherited (RecvChunk) at all ?
  1917.     do {
  1918.         ReadALine();
  1919.         if (fInfo == NULL) tooBig= false;
  1920.         else tooBig= (GetHandleSize( fInfo) >= maxchunk);
  1921.     } while (!(tooBig || EndOfMessage())); 
  1922. }
  1923.  
  1924.  
  1925. void CCSOPhoneBookGopher::addQuery( long qname, CStr255& query, TWindow* aWind)
  1926. {
  1927.     const short    kOperContains = 1;
  1928.     const short    kOperStarts    = 2;
  1929.     const short    kOperEquals    = 3;
  1930.     CStr255        aStr, bStr;
  1931.  
  1932.     TCluster    *aClus = (TCluster*) aWind->FindSubView(qname);
  1933.     if (aClus!=NULL) {
  1934.         TEditText    *aValue = (TEditText*) aClus->FindSubView('TEXT');
  1935.         aValue->GetText( aStr);
  1936.         if (!aStr.IsEmpty()) {
  1937.             TPopup *aTitle = (TPopup*) aClus->FindSubView('NAME');
  1938.             aTitle->GetItemText( aTitle->GetCurrentItem(), bStr);
  1939.             query += " " + bStr + "=";
  1940.             TPopup *aOper= (TPopup*) aClus->FindSubView('OPER');
  1941.             switch (aOper->GetCurrentItem()) {
  1942.                 case kOperContains: query += "\"*" + aStr + "*\""; break;
  1943.                 case kOperStarts:        query += "\""  + aStr + "*\""; break;
  1944.                 case kOperEquals:        query += "\""  + aStr + "\""; break;
  1945.                 }
  1946.             }
  1947.         }
  1948. }
  1949.  
  1950. Boolean CCSOPhoneBookGopher::queryUser( CStr255& query)
  1951. {
  1952.     CStr255        aStr;
  1953.     Boolean        result= false;
  1954.     
  1955.     TWindow* aWind = (TWindow *)gViewServer->NewTemplateWindow(kGopherPhoneID, NULL);
  1956.     FailNIL( aWind);          
  1957.     //TDialogView    *aDlog = (TDialogView*) aWind->FindSubView('DLOG');
  1958.     aWind->SetModality( true); //PoseModally will fail !!
  1959.     IDType dismisser = aWind->PoseModally();
  1960.     if (dismisser == 'OKAY') {
  1961.         TCheckBox    *aAnd = (TCheckBox*) aWind->FindSubView('cAND');
  1962.         query= "";
  1963.         addQuery('cNM1', query, aWind);
  1964.         if (aAnd->IsOn()) addQuery('cNM2',query, aWind);
  1965.         if (!query.IsEmpty()) {
  1966.             query.Insert("query ", 1);
  1967.             //?? add 'quit' command to close up CSO ??
  1968.             aStr= "12quit"; 
  1969.             aStr[1]= chRtn;
  1970.             aStr[2]= chLineFeed;
  1971.             query= query + aStr;
  1972.             result= true;
  1973.             }            
  1974.         else
  1975.             result= false;
  1976.         }        
  1977.     else
  1978.         result= false;
  1979.     aWind->CloseAndFree(); 
  1980.     gApplication->UpdateAllWindows();
  1981.     return result;
  1982. }
  1983.  
  1984.  
  1985.  
  1986. #if GOOBSOLETE
  1987. short CCSOPhoneBookGopher::GopherIt() // override 
  1988. /********
  1989. example gopher entries for CSO:
  1990. Name=University of Illinois Urbana-Champaign
  1991. Type=2
  1992. Port=105
  1993. Path=
  1994. Host=ns.uiuc.edu
  1995.  
  1996. Simpe gopher CSO dialog:
  1997.  
  1998.   1. Name    :
  1999.   2. Phone   :
  2000.   3. E-Mail  :
  2001.   4. Address :
  2002.  
  2003.     Press 1-4 to change a field, Return to accept fields and continue
  2004. ***********/
  2005. {
  2006.     CStr255     query;             
  2007.     CommandNumber    result= cNoCommand;
  2008.     
  2009.      if (queryUser(query)) {
  2010.         long len = query.Length() + 2;
  2011.         char* queryptr= NewPtr(len);
  2012.         FailNIL(queryptr);
  2013.         strcpy( queryptr, "\t");
  2014.         strcat( queryptr, query);
  2015.         
  2016.         fQuery= queryptr; //(char*) &query[1];    
  2017.         result= DTextGopher::GopherIt(); //Handle as TextGopher 
  2018.         DisposePtr(queryptr);
  2019.         }
  2020.     return result;
  2021. }
  2022. #endif // GOOBSOLETE
  2023.  
  2024.  
  2025. void CCSOPhoneBookGopher::Initialize()    // override 
  2026. {
  2027.     fMacType= 'TEXT';  
  2028.     fMacSire= 'EDIT';
  2029.     fTransferType= kTransferText; //text/lines or binary or none ?
  2030.     fSaveToDisk= false;
  2031.     fLaunch= false;
  2032.     fCommand= cNewGopherFile;
  2033. }
  2034.  
  2035. CCSOPhoneBookGopher::CCSOPhoneBookGopher(): DTextGopher()
  2036. {
  2037.     Initialize();
  2038. }
  2039.  
  2040. CCSOPhoneBookGopher::CCSOPhoneBookGopher(CCSOPhoneBookGopher* aGopher): DTextGopher(aGopher)
  2041. {
  2042.     //Initialize();
  2043. }
  2044.  
  2045. CCSOPhoneBookGopher::CCSOPhoneBookGopher( char ctype, const char* link): DTextGopher( ctype, link)
  2046. {
  2047.     Initialize();
  2048. }
  2049.  
  2050. void CCSOPhoneBookGopher::InfoTask() 
  2051. {    
  2052.     fThreadState= kThreadDoneReading; 
  2053. }
  2054.  
  2055. DObject* CCSOPhoneBookGopher::Clone()
  2056. {
  2057.     CCSOPhoneBookGopher* aGopher= new CCSOPhoneBookGopher();
  2058.     aGopher->CopyGopher( this);
  2059.     return aGopher;
  2060. }
  2061.  
  2062. void CCSOPhoneBookGopher::DrawIcon( Nlm_RecT& area, short size)  /* override */ 
  2063. {
  2064.     gGopherIconID= kPhonebookIcon;
  2065.     gIconSize= size;
  2066.     DrawIconSub( area);
  2067. }
  2068.  
  2069. const char* CCSOPhoneBookGopher::GetKindName() 
  2070. { 
  2071.     return "CSO Phonebook";
  2072. }
  2073.  
  2074. #endif    // FIX_LATER
  2075.  
  2076.  
  2077.  
  2078.  
  2079. #ifdef FIX_LATER
  2080.     
  2081. Boolean CWhoisPhoneBookGopher::PoseQuestion(CStr255& query) //from DIndexGopher
  2082. {
  2083.     TWindow    *aWind = (TWindow *)gViewServer->NewTemplateWindow(kGopherSearchID, NULL);
  2084.     FailNIL( aWind);          
  2085.     TStaticText    *aTitle = (TStaticText*) aWind->FindSubView('TITL');
  2086.     if (aTitle && fLink)     aTitle->SetText( this->GetName() + CStr31("?"), kRedraw);
  2087.     TEditText    *aFindString = (TEditText*) aWind->FindSubView('QEST');
  2088.     //TDialogView    *aDlog = (TDialogView*) aWind->FindSubView('DLOG');
  2089.     aWind->SetModality( true); //PoseModally will fail !!
  2090.     IDType dismisser = aWind->PoseModally();
  2091.     if (dismisser == 'OKAY') {
  2092.         aFindString->GetText( query);  
  2093.         }        
  2094.     aWind->CloseAndFree(); 
  2095.     gApplication->UpdateAllWindows();
  2096.     return  (dismisser == 'OKAY');
  2097. }
  2098.  
  2099.  
  2100. #if GOOBSOLETE
  2101. short CWhoisPhoneBookGopher::GopherIt() // override 
  2102. {
  2103.     CStr255     query;    
  2104.     CommandNumber    result= cNoCommand;
  2105.     
  2106.     if (PoseQuestion(query)) { 
  2107.         long len = query.Length() + 2;
  2108.         char* queryptr= NewPtr(len);
  2109.         FailNIL(queryptr);
  2110.         strcpy( queryptr, "\t");
  2111.         strcat( queryptr, query);
  2112.         
  2113.         fQuery= queryptr;  
  2114.         result= DTextGopher::GopherIt(); //Handle as TextGopher 
  2115.         DisposePtr( queryptr);
  2116.         }
  2117.     return result;
  2118. }
  2119. #endif // GOOBSOLETE
  2120.  
  2121. void CWhoisPhoneBookGopher::Initialize()    // override 
  2122. {
  2123.     fMacType= 'TEXT';  
  2124.     fMacSire= 'EDIT';
  2125.     fTransferType= kTransferText; //text/lines or binary or none ?
  2126.     fSaveToDisk= false;
  2127.     fLaunch= false;
  2128.     fCommand= cNewGopherFile;
  2129. }
  2130.  
  2131. CWhoisPhoneBookGopher::CWhoisPhoneBookGopher(): DTextGopher()
  2132. {
  2133.     Initialize();
  2134. }
  2135.  
  2136. CWhoisPhoneBookGopher::CWhoisPhoneBookGopher(CWhoisPhoneBookGopher* aGopher): DTextGopher(aGopher)
  2137. {
  2138.     //Initialize();
  2139. }
  2140.  
  2141. CWhoisPhoneBookGopher::CWhoisPhoneBookGopher( char ctype, const char* link): DTextGopher( ctype, link)
  2142. {
  2143.     Initialize();
  2144. }
  2145.  
  2146. DObject* CWhoisPhoneBookGopher::Clone()
  2147. {
  2148.     CWhoisPhoneBookGopher* aGopher= new CWhoisPhoneBookGopher();
  2149.     aGopher->CopyGopher( this);
  2150.     return aGopher;
  2151. }
  2152.  
  2153. void CWhoisPhoneBookGopher::InfoTask() 
  2154. {    
  2155.     fThreadState= kThreadDoneReading; 
  2156. }
  2157.  
  2158. void CWhoisPhoneBookGopher::DrawIcon( Nlm_RecT& area, short size)  /* override */ 
  2159. {
  2160.     gGopherIconID= kWhoisPhonebookIcon;
  2161.     gIconSize= size;
  2162.     DrawIconSub( area);
  2163. }
  2164.  
  2165. const char* CWhoisPhoneBookGopher::GetKindName() 
  2166. { 
  2167.     return "Whois Phonebook";
  2168. }
  2169.  
  2170. #endif    // FIX_LATER
  2171.  
  2172.  
  2173.  
  2174.  
  2175.  
  2176. #ifdef FIX_LATER
  2177.  
  2178. void CUuencodeGopher::Initialize()    // override 
  2179. {
  2180.     //? fType= kTypeUuencode; 
  2181.     fMacType= 'TEXT';  
  2182.     fMacSire= 'EDIT';
  2183.     fTransferType= kTransferText; //text/lines or binary or none ?
  2184.     fSaveToDisk= false;
  2185.     fLaunch= false;
  2186.     fCommand= cNewGopherFile;
  2187. }
  2188.  
  2189. CUuencodeGopher::CUuencodeGopher(): DTextGopher()
  2190. {
  2191.     Initialize();
  2192. }
  2193.  
  2194. CUuencodeGopher::CUuencodeGopher(CUuencodeGopher* aGopher): DTextGopher(aGopher)
  2195. {
  2196.     //Initialize();
  2197. }
  2198.  
  2199. CUuencodeGopher::CUuencodeGopher( char ctype, const char* link):
  2200.     DTextGopher( ctype, link)
  2201. {
  2202.     Initialize();
  2203. }
  2204.  
  2205. DObject* CUuencodeGopher::Clone()
  2206. {
  2207.     CUuencodeGopher* aGopher= new CUuencodeGopher();
  2208.     aGopher->CopyGopher( this);
  2209.     return aGopher;
  2210. }
  2211.  
  2212. void CUuencodeGopher::DrawIcon( Nlm_RecT& area, short size)  /* override */ 
  2213. {
  2214.     gGopherIconID= kUuencodeIcon;
  2215.     gIconSize= size;
  2216.     DrawIconSub( area);
  2217. }
  2218.  
  2219. const char* CUuencodeGopher::GetKindName() 
  2220. { 
  2221.     return "UU encoded file";
  2222. }
  2223.  
  2224. #if GOOBSOLETE
  2225. short CUuencodeGopher::GopherIt(void) // override 
  2226. {
  2227.     return DTextGopher::GopherIt();
  2228. }
  2229. #endif // GOOBSOLETE
  2230.  
  2231. #endif    // FIX_LATER
  2232.  
  2233.  
  2234.  
  2235.  
  2236.  
  2237. /** gopher+ view_names...
  2238.           case kTypeFile:
  2239.           case kTypeCSO:    view = "Text"; break;
  2240.           case kTypeGif:    view = "image/gif"; break;
  2241.           case kTypeImage:  view = "image";  break;
  2242.           case kTypeSound:  view = "audio/mulaw"; break;
  2243.           case kTypeTn3270: view = "terminal/tn3270";  break;
  2244.           case kTypeTelnet: view = "terminal/telnet";  break;
  2245.  
  2246. # An example gopherd+.conf file
  2247. #
  2248.  
  2249. # Different Languages
  2250. viewext: .txt.spanish 0 0 Text Es_ES
  2251. viewext: .txt.german 0 0 Text De_DE
  2252. viewext: .txt.french 0 0 Text Fr_FR
  2253.  
  2254.  
  2255. #data formats
  2256. #viewext: Filename extension / Advertised type-char / transfer type / +VIEWS type
  2257.  
  2258. viewext: .hqx 4 0 file/hqx
  2259.  
  2260. #
  2261. # Telnet file formats
  2262. #
  2263. viewext: .telnet 8 0 terminal/telnet
  2264. viewext: .tn3270 T 0 terminal/tn3270
  2265.  
  2266. #
  2267. # Graphics file formats
  2268. #
  2269. viewext: .gif I 9 image/gif
  2270. viewext: .pcx I 9 image/pcx
  2271. viewext: .pict I 9 image/PICT
  2272. viewext: .tiff I 9 image/TIFF
  2273. viewext: .jpg I 9 image/JPEG
  2274. viewext: .ppm I 9 image/ppm
  2275. viewext: .pgm I 9 image/pgm
  2276. viewext: .pbm I 9 image/pgm
  2277.  
  2278. #
  2279. # Sounds
  2280. #
  2281. viewext: .au s s audio/mulaw
  2282. viewext: .snd s s audio/mulaw
  2283. viewext: .wav s s audio/wave
  2284.  
  2285. #
  2286. # Movies
  2287. #
  2288. viewext: .quicktime 9 9 video/quicktime
  2289. viewext: .mpg 9 9 video/mpeg
  2290.  
  2291. #
  2292. # Binary files
  2293. #
  2294. viewext: .tar.Z 9 9 file/tar.Z
  2295. viewext: .tar 9 9 file/tar
  2296. viewext: .zip 5 9 file/PKzip
  2297. viewext: .zoo 5 9 file/Zoo
  2298. viewext: .arc 5 9 file/Arc
  2299. viewext: .lzh 5 9 file/Lharc
  2300. viewext: .exe 5 9 file/PCEXE
  2301. viewext: .mcb 9 9 file/MacBinary
  2302. viewext: .uu 9 9 file/uuencode
  2303.  
  2304.  
  2305. #
  2306. # Various forms of text
  2307. #
  2308. viewext: .ps 0 0 Text/postscript
  2309. viewext: .tex 0 0 Text/tex
  2310. viewext: .dvi 0 9 Text/dvi
  2311. viewext: .troff 0 0 Text/troff
  2312. viewext: .unicode 0 0 Text/unicode
  2313. viewext: .sjis 0 0 Text/sjis
  2314. viewext: .jis 0 0 Text/jis
  2315. viewext: .euc 0 0 Text/jis
  2316. viewext: .big5 0 0 Text/big-5
  2317. viewext: .rtf 0 0 Text/rtf
  2318. viewext: .word5 0 0 Text/MSWord5
  2319. viewext: .word4 0 0 Text/MSWord4
  2320. viewext: .mw 0 0 Text/MacWrite
  2321. viewext: .wp 0 0 Text/WordPerfect51
  2322.  
  2323. viewext: .smell 9 9 smell/funky
  2324.  
  2325. #
  2326. #
  2327. viewext: .mindex 7 mindex: Directory
  2328. viewext: .src 7 waissrc: Directory
  2329. viewext: .html h GET /h application/WWW
  2330.  
  2331.  
  2332. #
  2333. # These are for the experimental gview
  2334. #
  2335. viewext: .gview 1 1 Directory+/gview
  2336. blockext: .spot GVIEWSPOT
  2337.  
  2338. # Map files to certain blocks
  2339. #
  2340. blockext: .abstract ABSTRACT
  2341. blockext: .ask ASK
  2342.  
  2343. ****/
  2344.